package com.eduagent.xwqeduagent.api.characterRecognition.PhotographySpeedCalculation;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 拍照速算识别结果类
 */
@Data
public class PhotographySpeedCalculationResult {
    // 会话ID
    private String sid;
    
    // 返回码
    private int code;
    
    // 返回消息
    private String message;
    
    // 是否成功
    private boolean success;
    
    // 异常信息属性
    private String attrException;
    
    // 题型类别
    private String category;
    
    // 接口版本号
    private String version;
    
    // 识别结果列表
    private List<SpeedCalculationItem> items;
    
    /**
     * 速算题项目类
     */
    @Data
    public static class SpeedCalculationItem {
        // 公式内容
        private String content;
        
        // 公式置信度
        private double confidence;
        
        // 判决正误信息(1正确/0错误)
        private int totalScore;
        
        // 拒识标志(非0表示拒识)
        private int recRejection;
        
        // 公式区域信息
        private Rectangle rectangle;
    }
    
    /**
     * 矩形区域类
     */
    @Data
    public static class Rectangle {
        // 左上角X坐标
        private int leftUpX;
        
        // 左上角Y坐标
        private int leftUpY;
        
        // 右下角X坐标
        private int rightDownX;
        
        // 右下角Y坐标
        private int rightDownY;
    }
    
    /**
     * 解析识别结果
     * 
     * @param jsonResult JSON格式的识别结果
     * @return 解析后的结果对象
     */
    public static PhotographySpeedCalculationResult parseResult(String jsonResult) {
        PhotographySpeedCalculationResult result = new PhotographySpeedCalculationResult();
        
        try {
            JSONObject jsonObj = JSON.parseObject(jsonResult);
            
            // 解析基本信息
            result.setCode(jsonObj.getIntValue("code"));
            result.setMessage(jsonObj.getString("message"));
            result.setSid(jsonObj.getString("sid"));
            result.setSuccess(result.getCode() == 0);
            
            // 如果返回成功，解析data部分
            if (result.isSuccess() && jsonObj.containsKey("data")) {
                JSONObject data = jsonObj.getJSONObject("data");
                
                // 解析ITRResult
                if (data.containsKey("ITRResult")) {
                    JSONObject itrResult = data.getJSONObject("ITRResult");
                    
                    // 设置基本属性
                    result.setAttrException(itrResult.getString("attr_exception"));
                    result.setCategory(itrResult.getString("category"));
                    result.setVersion(itrResult.getString("version"));
                    
                    // 创建存储速算题项目的列表
                    List<SpeedCalculationItem> items = new ArrayList<>();
                    
                    // 解析多行信息
                    if (itrResult.containsKey("multi_line_info")) {
                        JSONObject multiLineInfo = itrResult.getJSONObject("multi_line_info");
                        
                        if (multiLineInfo.containsKey("imp_line_info")) {
                            JSONArray lineInfos = multiLineInfo.getJSONArray("imp_line_info");
                            
                            // 同时解析recog_result以获取具体内容
                            JSONArray recogResults = itrResult.getJSONArray("recog_result");
                            JSONObject firstRecogResult = recogResults.getJSONObject(0);
                            JSONArray lineWordResults = firstRecogResult.getJSONObject("line_word_result").getJSONArray("word_content");
                            JSONArray confidences = firstRecogResult.getJSONObject("line_word_result").getJSONArray("word_gwpp");
                            
                            // 确保行数匹配
                            int lineCount = Math.min(lineInfos.size(), lineWordResults.size());
                            
                            for (int i = 0; i < lineCount; i++) {
                                JSONObject lineInfo = lineInfos.getJSONObject(i);
                                
                                SpeedCalculationItem item = new SpeedCalculationItem();
                                
                                // 设置内容和置信度
                                item.setContent(i < lineWordResults.size() ? lineWordResults.getString(i) : "");
                                item.setConfidence(i < confidences.size() ? confidences.getDoubleValue(i) : 0.0);
                                
                                // 设置正误判断和拒识标志
                                item.setTotalScore(lineInfo.getIntValue("total_score"));
                                item.setRecRejection(lineInfo.getIntValue("rec_rejection"));
                                
                                // 设置矩形区域
                                if (lineInfo.containsKey("imp_line_rect")) {
                                    JSONObject rect = lineInfo.getJSONObject("imp_line_rect");
                                    
                                    Rectangle rectangle = new Rectangle();
                                    rectangle.setLeftUpX(rect.getIntValue("left_up_point_x"));
                                    rectangle.setLeftUpY(rect.getIntValue("left_up_point_y"));
                                    rectangle.setRightDownX(rect.getIntValue("right_down_point_x"));
                                    rectangle.setRightDownY(rect.getIntValue("right_down_point_y"));
                                    
                                    item.setRectangle(rectangle);
                                }
                                
                                items.add(item);
                            }
                        }
                    }
                    
                    result.setItems(items);
                }
            }
            
        } catch (Exception e) {
            result.setSuccess(false);
            result.setCode(-1);
            result.setMessage("解析结果异常: " + e.getMessage());
        }
        
        return result;
    }
    
    /**
     * 获取所有公式文本
     * 
     * @return 公式文本列表
     */
    public List<String> getAllFormulas() {
        List<String> formulas = new ArrayList<>();
        if (items != null) {
            for (SpeedCalculationItem item : items) {
                formulas.add(item.getContent());
            }
        }
        return formulas;
    }
    
    /**
     * 获取所有正确的公式文本
     * 
     * @return 正确的公式文本列表
     */
    public List<String> getCorrectFormulas() {
        List<String> formulas = new ArrayList<>();
        if (items != null) {
            for (SpeedCalculationItem item : items) {
                if (item.getTotalScore() == 1) {
                    formulas.add(item.getContent());
                }
            }
        }
        return formulas;
    }
    
    /**
     * 获取所有错误的公式文本
     * 
     * @return 错误的公式文本列表
     */
    public List<String> getIncorrectFormulas() {
        List<String> formulas = new ArrayList<>();
        if (items != null) {
            for (SpeedCalculationItem item : items) {
                if (item.getTotalScore() == 0) {
                    formulas.add(item.getContent());
                }
            }
        }
        return formulas;
    }
    
    /**
     * 统计正确和错误的公式数量
     * 
     * @return 包含正确和错误公式数量的Map
     */
    public Map<String, Integer> getStatistics() {
        int correct = 0;
        int incorrect = 0;
        
        if (items != null) {
            for (SpeedCalculationItem item : items) {
                if (item.getTotalScore() == 1) {
                    correct++;
                } else {
                    incorrect++;
                }
            }
        }
        
        return Map.of("correct", correct, "incorrect", incorrect, "total", items != null ? items.size() : 0);
    }
} 